home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / gedit-2 / plugins / pythonconsole / console.py < prev    next >
Encoding:
Python Source  |  2009-04-14  |  10.2 KB  |  327 lines
  1. # -*- coding: utf-8 -*-
  2.  
  3. # pythonconsole.py -- Console widget
  4. #
  5. # Copyright (C) 2006 - Steve Fr√©cinaux
  6. #
  7. # This program is free software; you can redistribute it and/or modify
  8. # it under the terms of the GNU General Public License as published by
  9. # the Free Software Foundation; either version 2, or (at your option)
  10. # any later version.
  11. # 
  12. # This program is distributed in the hope that it will be useful,
  13. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. # GNU General Public License for more details.
  16. #
  17. # You should have received a copy of the GNU General Public License
  18. # along with this program; if not, write to the Free Software
  19. # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20.  
  21. # Parts from "Interactive Python-GTK Console" (stolen from epiphany's console.py)
  22. #     Copyright (C), 1998 James Henstridge <james@daa.com.au>
  23. #     Copyright (C), 2005 Adam Hooper <adamh@densi.com>
  24. # Bits from gedit Python Console Plugin
  25. #     Copyrignt (C), 2005 Rapha√´l Slinckx
  26.  
  27. import string
  28. import sys
  29. import re
  30. import traceback
  31. import gobject
  32. import gtk
  33. import pango
  34.  
  35. from config import PythonConsoleConfig
  36.  
  37. __all__ = ('PythonConsole', 'OutFile')
  38.  
  39. class PythonConsole(gtk.ScrolledWindow):
  40.     def __init__(self, namespace = {}):
  41.         gtk.ScrolledWindow.__init__(self)
  42.  
  43.         self.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
  44.         self.set_shadow_type(gtk.SHADOW_IN)
  45.         self.view = gtk.TextView()
  46.         self.view.modify_font(pango.FontDescription('Monospace'))
  47.         self.view.set_editable(True)
  48.         self.view.set_wrap_mode(gtk.WRAP_WORD_CHAR)
  49.         self.add(self.view)
  50.         self.view.show()
  51.  
  52.         buffer = self.view.get_buffer()
  53.         self.normal = buffer.create_tag("normal")
  54.         self.error  = buffer.create_tag("error")
  55.         self.command = buffer.create_tag("command")
  56.  
  57.         PythonConsoleConfig.add_handler(self.apply_preferences)
  58.         self.apply_preferences()
  59.  
  60.         self.__spaces_pattern = re.compile(r'^\s+')
  61.         self.namespace = namespace
  62.  
  63.         self.block_command = False
  64.  
  65.         # Init first line
  66.         buffer.create_mark("input-line", buffer.get_end_iter(), True)
  67.         buffer.insert(buffer.get_end_iter(), ">>> ")
  68.         buffer.create_mark("input", buffer.get_end_iter(), True)
  69.  
  70.         # Init history
  71.         self.history = ['']
  72.         self.history_pos = 0
  73.         self.current_command = ''
  74.         self.namespace['__history__'] = self.history
  75.  
  76.         # Set up hooks for standard output.
  77.         self.stdout = OutFile(self, sys.stdout.fileno(), self.normal)
  78.         self.stderr = OutFile(self, sys.stderr.fileno(), self.error)
  79.         
  80.         # Signals
  81.         self.view.connect("key-press-event", self.__key_press_event_cb)
  82.         buffer.connect("mark-set", self.__mark_set_cb)
  83.         
  84.     def apply_preferences(self, *args):
  85.         config = PythonConsoleConfig()
  86.         self.error.set_property("foreground", config.color_error)
  87.         self.command.set_property("foreground", config.color_command)
  88.         
  89.     def stop(self):
  90.         self.namespace = None
  91.  
  92.     def __key_press_event_cb(self, view, event):
  93.         modifier_mask = gtk.accelerator_get_default_mod_mask()
  94.         event_state = event.state & modifier_mask
  95.  
  96.         if event.keyval == gtk.keysyms.d and event_state == gtk.gdk.CONTROL_MASK:
  97.             self.destroy()
  98.  
  99.         elif event.keyval == gtk.keysyms.Return and event_state == gtk.gdk.CONTROL_MASK:
  100.             # Get the command
  101.             buffer = view.get_buffer()
  102.             inp_mark = buffer.get_mark("input")
  103.             inp = buffer.get_iter_at_mark(inp_mark)
  104.             cur = buffer.get_end_iter()
  105.             line = buffer.get_text(inp, cur)
  106.             self.current_command = self.current_command + line + "\n"
  107.             self.history_add(line)
  108.  
  109.             # Prepare the new line
  110.             cur = buffer.get_end_iter()
  111.             buffer.insert(cur, "\n... ")
  112.             cur = buffer.get_end_iter()
  113.             buffer.move_mark(inp_mark, cur)
  114.             
  115.             # Keep indentation of precendent line
  116.             spaces = re.match(self.__spaces_pattern, line)
  117.             if spaces is not None:
  118.                 buffer.insert(cur, line[spaces.start() : spaces.end()])
  119.                 cur = buffer.get_end_iter()
  120.                 
  121.             buffer.place_cursor(cur)
  122.             gobject.idle_add(self.scroll_to_end)
  123.             return True
  124.         
  125.         elif event.keyval == gtk.keysyms.Return:
  126.             # Get the marks
  127.             buffer = view.get_buffer()
  128.             lin_mark = buffer.get_mark("input-line")
  129.             inp_mark = buffer.get_mark("input")
  130.  
  131.             # Get the command line
  132.             inp = buffer.get_iter_at_mark(inp_mark)
  133.             cur = buffer.get_end_iter()
  134.             line = buffer.get_text(inp, cur)
  135.             self.current_command = self.current_command + line + "\n"
  136.             self.history_add(line)
  137.  
  138.             # Make the line blue
  139.             lin = buffer.get_iter_at_mark(lin_mark)
  140.             buffer.apply_tag(self.command, lin, cur)
  141.             buffer.insert(cur, "\n")
  142.             
  143.             cur_strip = self.current_command.rstrip()
  144.  
  145.             if cur_strip.endswith(":") \
  146.             or (self.current_command[-2:] != "\n\n" and self.block_command):
  147.                 # Unfinished block command
  148.                 self.block_command = True
  149.                 com_mark = "... "
  150.             elif cur_strip.endswith("\\"):
  151.                 com_mark = "... "
  152.             else:
  153.                 # Eval the command
  154.                 self.__run(self.current_command)
  155.                 self.current_command = ''
  156.                 self.block_command = False
  157.                 com_mark = ">>> "
  158.  
  159.             # Prepare the new line
  160.             cur = buffer.get_end_iter()
  161.             buffer.move_mark(lin_mark, cur)
  162.             buffer.insert(cur, com_mark)
  163.             cur = buffer.get_end_iter()
  164.             buffer.move_mark(inp_mark, cur)
  165.             buffer.place_cursor(cur)
  166.             gobject.idle_add(self.scroll_to_end)
  167.             return True
  168.  
  169.         elif event.keyval == gtk.keysyms.KP_Down or event.keyval == gtk.keysyms.Down:
  170.             # Next entry from history
  171.             view.emit_stop_by_name("key_press_event")
  172.             self.history_down()
  173.             gobject.idle_add(self.scroll_to_end)
  174.             return True
  175.  
  176.         elif event.keyval == gtk.keysyms.KP_Up or event.keyval == gtk.keysyms.Up:
  177.             # Previous entry from history
  178.             view.emit_stop_by_name("key_press_event")
  179.             self.history_up()
  180.             gobject.idle_add(self.scroll_to_end)
  181.             return True
  182.  
  183.         elif event.keyval == gtk.keysyms.KP_Left or event.keyval == gtk.keysyms.Left or \
  184.              event.keyval == gtk.keysyms.BackSpace:
  185.             buffer = view.get_buffer()
  186.             inp = buffer.get_iter_at_mark(buffer.get_mark("input"))
  187.             cur = buffer.get_iter_at_mark(buffer.get_insert())
  188.             if inp.compare(cur) == 0:
  189.                 if not event_state:
  190.                     buffer.place_cursor(inp)
  191.                 return True
  192.             return False
  193.  
  194.         elif (event.keyval == gtk.keysyms.KP_Home or event.keyval == gtk.keysyms.Home) and \
  195.              event_state == event_state & (gtk.gdk.SHIFT_MASK|gtk.gdk.CONTROL_MASK):
  196.             # Go to the begin of the command instead of the begin of the line
  197.             buffer = view.get_buffer()
  198.             inp = buffer.get_iter_at_mark(buffer.get_mark("input"))
  199.             if event_state & gtk.gdk.SHIFT_MASK:
  200.                 buffer.move_mark_by_name("insert", inp)
  201.             else:
  202.                 buffer.place_cursor(inp)
  203.             return True
  204.         
  205.     def __mark_set_cb(self, buffer, iter, name):
  206.         input = buffer.get_iter_at_mark(buffer.get_mark("input"))
  207.         pos   = buffer.get_iter_at_mark(buffer.get_insert())
  208.         self.view.set_editable(pos.compare(input) != -1)
  209.  
  210.     def get_command_line(self):
  211.         buffer = self.view.get_buffer()
  212.         inp = buffer.get_iter_at_mark(buffer.get_mark("input"))
  213.         cur = buffer.get_end_iter()
  214.         return buffer.get_text(inp, cur)
  215.     
  216.     def set_command_line(self, command):
  217.         buffer = self.view.get_buffer()
  218.         mark = buffer.get_mark("input")
  219.         inp = buffer.get_iter_at_mark(mark)
  220.         cur = buffer.get_end_iter()
  221.         buffer.delete(inp, cur)
  222.         buffer.insert(inp, command)
  223.         self.view.grab_focus()
  224.     
  225.     def history_add(self, line):
  226.         if line.strip() != '':
  227.             self.history_pos = len(self.history)
  228.             self.history[self.history_pos - 1] = line
  229.             self.history.append('')
  230.     
  231.     def history_up(self):
  232.         if self.history_pos > 0:
  233.             self.history[self.history_pos] = self.get_command_line()
  234.             self.history_pos = self.history_pos - 1
  235.             self.set_command_line(self.history[self.history_pos])
  236.             
  237.     def history_down(self):
  238.         if self.history_pos < len(self.history) - 1:
  239.             self.history[self.history_pos] = self.get_command_line()
  240.             self.history_pos = self.history_pos + 1
  241.             self.set_command_line(self.history[self.history_pos])
  242.     
  243.     def scroll_to_end(self):
  244.         iter = self.view.get_buffer().get_end_iter()
  245.         self.view.scroll_to_iter(iter, 0.0)
  246.         return False
  247.  
  248.     def write(self, text, tag = None):
  249.         buffer = self.view.get_buffer()
  250.         if tag is None:
  251.             buffer.insert(buffer.get_end_iter(), text)
  252.         else:
  253.             buffer.insert_with_tags(buffer.get_end_iter(), text, tag)
  254.         gobject.idle_add(self.scroll_to_end)
  255.      
  256.      def eval(self, command, display_command = False):
  257.         buffer = self.view.get_buffer()
  258.         lin = buffer.get_mark("input-line")
  259.         buffer.delete(buffer.get_iter_at_mark(lin),
  260.                       buffer.get_end_iter())
  261.  
  262.         if isinstance(command, list) or isinstance(command, tuple):
  263.              for c in command:
  264.                  if display_command:
  265.                      self.write(">>> " + c + "\n", self.command)
  266.                  self.__run(c)
  267.         else:
  268.              if display_command:
  269.                  self.write(">>> " + c + "\n", self.command)
  270.             self.__run(command) 
  271.  
  272.         cur = buffer.get_end_iter()
  273.         buffer.move_mark_by_name("input-line", cur)
  274.         buffer.insert(cur, ">>> ")
  275.         cur = buffer.get_end_iter()
  276.         buffer.move_mark_by_name("input", cur)
  277.         self.view.scroll_to_iter(buffer.get_end_iter(), 0.0)
  278.     
  279.      def __run(self, command):
  280.         sys.stdout, self.stdout = self.stdout, sys.stdout
  281.         sys.stderr, self.stderr = self.stderr, sys.stderr
  282.  
  283.         # eval and exec are broken in how they deal with utf8-encoded
  284.         # strings so we have to explicitly decode the command before
  285.         # passing it along
  286.         command = command.decode('utf8')
  287.  
  288.         try:
  289.             try:
  290.                 r = eval(command, self.namespace, self.namespace)
  291.                 if r is not None:
  292.                     print `r`
  293.             except SyntaxError:
  294.                 exec command in self.namespace
  295.         except:
  296.             if hasattr(sys, 'last_type') and sys.last_type == SystemExit:
  297.                 self.destroy()
  298.             else:
  299.                 traceback.print_exc()
  300.  
  301.         sys.stdout, self.stdout = self.stdout, sys.stdout
  302.         sys.stderr, self.stderr = self.stderr, sys.stderr
  303.  
  304.     def destroy(self):
  305.         pass
  306.         #gtk.ScrolledWindow.destroy(self)
  307.         
  308. class OutFile:
  309.     """A fake output file object. It sends output to a TK test widget,
  310.     and if asked for a file number, returns one set on instance creation"""
  311.     def __init__(self, console, fn, tag):
  312.         self.fn = fn
  313.         self.console = console
  314.         self.tag = tag
  315.     def close(self):         pass
  316.     def flush(self):         pass
  317.     def fileno(self):        return self.fn
  318.     def isatty(self):        return 0
  319.     def read(self, a):       return ''
  320.     def readline(self):      return ''
  321.     def readlines(self):     return []
  322.     def write(self, s):      self.console.write(s, self.tag)
  323.     def writelines(self, l): self.console.write(l, self.tag)
  324.     def seek(self, a):       raise IOError, (29, 'Illegal seek')
  325.     def tell(self):          raise IOError, (29, 'Illegal seek')
  326.     truncate = tell
  327.